package com.siashan.toolkit.crypt.digest;

import com.siashan.toolkit.crypt.binary.Hex;
import com.siashan.toolkit.crypt.util.StringUtils;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Files;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * 摘要算法工具类
 *
 * 参考了commons-codec和hutool-crypto的设计思路，整合了两者优秀的代码，摒弃部分不合理或者使用不方便的代码，旨在提供一个更易上手
 * 和使用的摘要计算工具类。
 *
 * @author siashan
 * @since v1.0.7
 */
public class DigestUtil {

    /**
     * 缓存大小
     */
    private static final int STREAM_BUFFER_LENGTH = 1024;


    /**
     * 消息摘要实例
     */
    private final MessageDigest messageDigest;


    /**
     * 构造方法
     *
     * @param digest 摘要实例
     * @since 1.0.7
     */
    public DigestUtil(final MessageDigest digest) {
        this.messageDigest = digest;
    }

    /**
     * 构造方法
     *
     * @param name 摘要算法名称
     * @since 1.0.7
     */
    public DigestUtil(final String name) {
        this(getDigest(name));
    }


//--------------------------------------------- 获取摘要实例 ----------------------------------------------------------//

    /**
     * 获取消息摘要
     *
     * @param algorithm 算法
     * @return 消息摘要实例
     * @since 1.0.7
     */
    public static MessageDigest getDigest(final String algorithm) {
        try {
            return MessageDigest.getInstance(algorithm);
        } catch (final NoSuchAlgorithmException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * 获取消息摘要
     *
     * @param algorithm  算法
     * @param defaultMessageDigest   默认消息摘要实例
     * @return 摘要算法实例.
     * @since 1.0.7
     */
    public static MessageDigest getDigest(final String algorithm, final MessageDigest defaultMessageDigest) {
        try {
            return MessageDigest.getInstance(algorithm);
        } catch (final Exception e) {
            return defaultMessageDigest;
        }
    }

    /**
     * 获取消息摘要
     *
     * @param algorithm 算法
     * @return 消息摘要实例
     * @since 1.0.7
     */
    public static MessageDigest getDigest(final DigestAlgorithm algorithm) {
        return getDigest(algorithm.getValue());
    }

    /**
     * 获取 MD2 消息摘要.
     *
     * @return MD2 消息摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getMd2Digest() {
        return getDigest(DigestAlgorithm.MD2);
    }

    /**
     * 获取 MD5 消息摘要.
     *
     * @return MD5 消息摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getMd5Digest() {
        return getDigest(DigestAlgorithm.MD5);
    }

    /**
     * 获取 SHA-1 消息摘要.
     *
     * @return SHA-1 摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getSha1Digest() {
        return getDigest(DigestAlgorithm.SHA_1);
    }

    /**
     * 获取 SHA-256 消息摘要.
     *
     * @return SHA-256 摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getSha256Digest() {
        return getDigest(DigestAlgorithm.SHA_256);
    }

    /**
     * 获取 SHA3-224 消息摘要.
     *
     * @return SHA3-224 摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getSha3_224Digest() {
        return getDigest(DigestAlgorithm.SHA3_224);
    }

    /**
     * 获取 SHA3-256 消息摘要.
     *
     * @return SHA3-256 摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getSha3_256Digest() {
        return getDigest(DigestAlgorithm.SHA3_256);
    }

    /**
     * 获取 SHA3-384 消息摘要.
     *
     * @return SHA3-384 摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getSha3_384Digest() {
        return getDigest(DigestAlgorithm.SHA3_384);
    }

    /**
     * 获取 SHA3-512 消息摘要.
     *
     * @return SHA3-512 摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getSha3_512Digest() {
        return getDigest(DigestAlgorithm.SHA3_512);
    }

    /**
     * 获取 SHA-384 消息摘要.
     *
     * @return SHA-384 摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getSha384Digest() {
        return getDigest(DigestAlgorithm.SHA_384);
    }

    /**
     * 获取 SHA-512/224 消息摘要.
     *
     * @return SHA-512/224 摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getSha512_224Digest() {
        return getDigest(DigestAlgorithm.SHA_512_224);
    }

    /**
     * 获取 SHA-512/256 消息摘要.
     *
     * @return SHA-512/256 摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getSha512_256Digest() {
        return getDigest(DigestAlgorithm.SHA_512_256);
    }

    /**
     * 获取 SHA-512 消息摘要.
     *
     * @return SHA-512 摘要实例.
     * @since 1.0.7
     */
    public static MessageDigest getSha512Digest() {
        return getDigest(DigestAlgorithm.SHA_512);
    }


    /**
     * 获取 SM3 消息摘要
     *
     * @return SM3 摘要实例
     * @since 1.0.7
     */
    public static MessageDigest getSM3Digest(){
        return getDigest(DigestAlgorithm.SM3);
    }

    /**
     * 判断算法是否支持
     *
     * @param algorithm 算法名称
     * @return 是否支持
     * @since 1.0.7
     */
    public static boolean isAvailable(final String algorithm) {
        return getDigest(algorithm, null) != null;
    }

//-------------------------------------- 消息摘要 ---------------------------------------------------------------------//

    /**
     * 消息摘要
     *
     * @param messageDigest  消息摘要实例
     * @param data  要进行摘要计算的字节数组
     * @return 消息摘要结果
     * @since 1.0.7
     */
    public static byte[] digest(final MessageDigest messageDigest, final byte[] data) {
        return messageDigest.digest(data);
    }

    /**
     * 消息摘要
     *
     * @param messageDigest  消息摘要实例
     * @param data  要进行摘要计算的数据
     * @return 消息摘要结果
     *
     * @since 1.0.7
     */
    public static byte[] digest(final MessageDigest messageDigest, final ByteBuffer data) {
        messageDigest.update(data);
        return messageDigest.digest();
    }

    /**
     * 消息摘要
     *
     * @param messageDigest  消息摘要实例
     * @param data   要进行摘要计算的文件
     * @return 摘要计算结果
     * @throws IOException  IO异常
     * @since 1.0.7
     */
    public static byte[] digest(final MessageDigest messageDigest, final File data) throws IOException {
        return updateDigest(messageDigest, data).digest();
    }

    /**
     * 消息摘要
     *
     * @param messageDigest  消息摘要实例
     * @param data 要进行摘要计算的输入流
     * @return 摘要计算结果
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] digest(final MessageDigest messageDigest, final InputStream data) throws IOException {
        return updateDigest(messageDigest, data).digest();
    }

    /**
     * 消息摘要
     *
     * @param messageDigest 消息摘要实例
     * @param data 需要进行摘要计算的文件地址
     * @param options  如何打开文件的选项
     * @return 摘要计算结果
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] digest(final MessageDigest messageDigest, final Path data, final OpenOption... options)
            throws IOException {
        return updateDigest(messageDigest, data, options).digest();
    }

    /**
     * 消息摘要
     *
     * @param messageDigest 消息摘要实例
     * @param data 需要进行摘要计算的文件
     * @return 摘要计算结果
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] digest(final MessageDigest messageDigest, final RandomAccessFile data) throws IOException {
        return updateDigest(messageDigest, data).digest();
    }

    /**
     * 消息摘要
     *
     * @param data      需要进行摘要计算的数据
     * @return 摘要计算结果
     * @since 1.0.7
     */
    public byte[] digest(final byte[] data) {
        return updateDigest(messageDigest, data).digest();
    }

    /**
     * 消息摘要
     *
     * @param data  需要进行摘要计算的数据
     * @return 摘要计算结果
     * @since 1.0.7
     */
    public byte[] digest(final ByteBuffer data) {
        return updateDigest(messageDigest, data).digest();
    }

    /**
     * 消息摘要
     *
     * @param data          需要进行摘要计算的数据
     * @return 摘要计算结果
     * @throws IOException  IO异常
     * @since 1.0.7
     */
    public byte[] digest(final File data) throws IOException {
        return updateDigest(messageDigest, data).digest();
    }

    /**
     * 消息摘要
     *
     * @param data      需要进行摘要计算的数据
     * @return 摘要计算结果
     * @throws IOException  IO异常
     * @since 1.0.7
     */
    public byte[] digest(final InputStream data) throws IOException {
        return updateDigest(messageDigest, data).digest();
    }

    /**
     * 消息摘要
     *
     * @param data      需要进行摘要计算的数据
     * @param options   文件打开方式
     * @return 摘要计算结果
     * @throws IOException  IO异常
     * @since 1.0.7
     */
    public byte[] digest(final Path data, final OpenOption... options) throws IOException {
        return updateDigest(messageDigest, data, options).digest();
    }

    /**
     * 消息摘要
     *
     * @param data      需要进行摘要计算的数据
     * @return 摘要计算结果
     * @since 1.0.7
     */
    public byte[] digest(final String data) {
        return updateDigest(messageDigest, data).digest();
    }

    /**
     * 消息摘要
     *
     * @param data      需要进行摘要计算的数据
     * @return 16进制摘要计算结果
     * @since 1.0.7
     */
    public String digestAsHex(final byte[] data) {
        return Hex.encodeHexString(digest(data));
    }

    /**
     * 消息摘要
     *
     * @param data      需要进行摘要计算的数据
     * @return 16进制摘要计算结果
     * @since 1.0.7
     */
    public String digestAsHex(final ByteBuffer data) {
        return Hex.encodeHexString(digest(data));
    }

    /**
     * 消息摘要
     *
     * @param data      需要进行摘要计算的数据
     * @return 16进制摘要计算结果
     * @throws IOException      IO异常
     * @since 1.0.7
     */
    public String digestAsHex(final File data) throws IOException {
        return Hex.encodeHexString(digest(data));
    }

    /**
     * 消息摘要
     *
     * @param data      需要进行摘要计算的数据
     * @return 16进制摘要计算结果
     * @throws IOException  IO异常
     * @since 1.0.7
     */
    public String digestAsHex(final InputStream data) throws IOException {
        return Hex.encodeHexString(digest(data));
    }

    /**
     * 消息摘要
     *
     * @param data      需要进行摘要计算的数据
     * @param options   文件打开方式
     * @return 16进制摘要计算结果
     * @throws IOException  IO异常
     * @since 1.0.7
     */
    public String digestAsHex(final Path data, final OpenOption... options) throws IOException {
        return Hex.encodeHexString(digest(data, options));
    }

    /**
     * 消息摘要
     *
     * @param data      需要进行摘要计算的数据
     * @return 16进制摘要计算结果
     * @since 1.0.7
     */
    public String digestAsHex(final String data) {
        return Hex.encodeHexString(digest(data));
    }

//--------------------------------------------- 更新摘要 -------------------------------------------------------------//

    /**
     * 更新摘要
     *
     * @param messageDigest  消息摘要实例
     * @param valueToDigest  更新摘要的值
     * @return 更新后的摘要
     * @since 1.0.7
     */
    public static MessageDigest updateDigest(final MessageDigest messageDigest, final byte[] valueToDigest) {
        messageDigest.update(valueToDigest);
        return messageDigest;
    }

    /**
     * 更新摘要
     *
     * @param messageDigest  消息摘要实例
     * @param valueToDigest  更新摘要的值
     * @return 更新后的摘要
     * @since 1.0.7
     */
    public static MessageDigest updateDigest(final MessageDigest messageDigest, final ByteBuffer valueToDigest) {
        messageDigest.update(valueToDigest);
        return messageDigest;
    }

    /**
     * 更新摘要
     *
     * @param digest   消息摘要实例
     * @param data     需要进行摘要计算的数据
     * @return 摘要实例
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static MessageDigest updateDigest(final MessageDigest digest, final File data) throws IOException {
        try (final BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(data))) {
            return updateDigest(digest, inputStream);
        }
    }

    /**
     * 更新摘要
     *
     * @param digest    消息摘要实例
     * @param data      需要进行摘要计算的数据
     * @return 摘要实例
     * @throws IOException IO异常
     * @since 1.0.7
     */
    private static MessageDigest updateDigest(final MessageDigest digest, final FileChannel data) throws IOException {
        final ByteBuffer buffer = ByteBuffer.allocate(STREAM_BUFFER_LENGTH);
        while (data.read(buffer) > 0) {
            buffer.flip();
            digest.update(buffer);
            buffer.clear();
        }
        return digest;
    }

    /**
     * 更新摘要
     *
     * @param digest        消息摘要实例
     * @param inputStream   需要进行摘要计算的数据
     * @return 摘要实例
     * @throws IOException  IO异常
     * @since 1.0.7
     */
    public static MessageDigest updateDigest(final MessageDigest digest, final InputStream inputStream)
            throws IOException {
        final byte[] buffer = new byte[STREAM_BUFFER_LENGTH];
        int read = inputStream.read(buffer, 0, STREAM_BUFFER_LENGTH);

        while (read > -1) {
            digest.update(buffer, 0, read);
            read = inputStream.read(buffer, 0, STREAM_BUFFER_LENGTH);
        }

        return digest;
    }

    /**
     * 更新摘要
     *
     * @param digest        摘要实例
     * @param path          需要进行摘要计算的文件地址
     * @param options       打开文件的方式
     * @return 摘要实例
     * @throws IOException  IO异常
     * @since 1.0.7
     */
    public static MessageDigest updateDigest(final MessageDigest digest, final Path path, final OpenOption... options)
            throws IOException {
        try (final BufferedInputStream inputStream = new BufferedInputStream(Files.newInputStream(path, options))) {
            return updateDigest(digest, inputStream);
        }
    }

    /**
     * 更新摘要
     *
     * @param digest            摘要实例
     * @param data              需要进行摘要计算的数据
     * @return 摘要实例
     * @throws IOException      IO异常
     * @since 1.0.7
     */
    public static MessageDigest updateDigest(final MessageDigest digest, final RandomAccessFile data)
            throws IOException {
        return updateDigest(digest, data.getChannel());
    }

    /**
     * 更新摘要
     *
     * @param messageDigest     摘要实例
     * @param valueToDigest     需要进行摘要计算的数据
     * @return 摘要实例
     * @since 1.0.7
     */
    public static MessageDigest updateDigest(final MessageDigest messageDigest, final String valueToDigest) {
        messageDigest.update(StringUtils.getBytesUtf8(valueToDigest));
        return messageDigest;
    }


    /**
     * 获取消息摘要实例
     *
     * @return 消息摘要实例
     * @since 1.0.7
     */
    public MessageDigest getMessageDigest() {
        return messageDigest;
    }

//------------------------------------------- 摘要算法  --------------------------------------------------------------//

    /**
     * md2摘要算法
     *
     * @param data      需要进行md2摘要计算的数据
     * @return MD2摘要计算结果
     * @since 1.0.7
     */
    public static byte[] md2(final byte[] data) {
        return getMd2Digest().digest(data);
    }

    /**
     * md2摘要算法
     *
     * @param data      需要进行md2摘要计算的数据
     * @return MD2摘要计算结果
     * @throws IOException  IO异常
     * @since 1.0.7
     */
    public static byte[] md2(final InputStream data) throws IOException {
        return digest(getMd2Digest(), data);
    }

    /**
     * md2摘要算法
     *
     * @param data      需要进行md2摘要计算的数据
     * @return MD2摘要计算结果
     * @since 1.0.7
     */
    public static byte[] md2(final String data) {
        return md2(StringUtils.getBytesUtf8(data));
    }

    /**
     * md2摘要算法
     * 计算MD2摘要并将值作为32个字符的十六进制字符串返回
     *
     * @param data      要进行摘要计算的数据
     * @return MD2摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String md2Hex(final byte[] data) {
        return Hex.encodeHexString(md2(data));
    }

    /**
     * md2摘要算法
     * 计算MD2摘要并将值作为32个字符的十六进制字符串返回
     *
     * @param data      要进行摘要计算的数据
     * @return MD2摘要计算后的十六进制字符串
     * @throws IOException  IO异常
     * @since 1.0.7
     */
    public static String md2Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(md2(data));
    }

    /**
     * md2摘要算法
     * 计算MD2摘要并将值作为32个字符的十六进制字符串返回
     *
     * @param data      要进行摘要计算的数据
     * @return MD2摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String md2Hex(final String data) {
        return Hex.encodeHexString(md2(data));
    }

    /**
     * md5摘要算法
     * 计算MD5摘要并将值作为16元素{@code byte[]}返回。
     *
     * @param data      要进行摘要计算的数据
     * @return MD5摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] md5(final byte[] data) {
        return getMd5Digest().digest(data);
    }

    /**
     * md5摘要算法
     * 计算MD5摘要并将值作为16元素{@code byte[]}返回。
     *
     * @param data      要进行摘要计算的数据
     * @throws IOException  IO异常
     * @return MD5摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] md5(final InputStream data) throws IOException {
        return digest(getMd5Digest(), data);
    }

//----------------------------------------------- MD5 摘要算法 --------------------------------------------------------//

    /**
     * md5摘要算法
     * 计算MD5摘要并将值作为16元素{@code byte[]}返回。
     *
     * @param data      要进行摘要计算的数据
     * @return MD5摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] md5(final String data) {
        return md5(StringUtils.getBytesUtf8(data));
    }

    /**
     * md5摘要算法
     * 计算MD5摘要并将值作为32个字符的十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return MD5摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String md5Hex(final byte[] data) {
        return Hex.encodeHexString(md5(data));
    }

    /**
     * md5摘要算法
     * 计算MD5摘要并将值作为32个字符的十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @throws IOException  IO异常
     * @return MD5摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String md5Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(md5(data));
    }

    /**
     * md5摘要算法
     * 计算MD5摘要并将值作为32个字符的十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return MD5摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String md5Hex(final String data) {
        return Hex.encodeHexString(md5(data));
    }

//--------------------------------------------- SHA-1 摘要算法 --------------------------------------------------------//

    /**
     * SHA-1摘要算法
     * 计算SHA-1摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-1摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha1(final byte[] data) {
        return getSha1Digest().digest(data);
    }

    /**
     * SHA-1摘要算法
     * 计算SHA-1摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-1摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sha1(final InputStream data) throws IOException {
        return digest(getSha1Digest(), data);
    }

    /**
     * SHA-1摘要算法
     * 计算SHA-1摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-1摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sha1(final String data) {
        return sha1(StringUtils.getBytesUtf8(data));
    }

    /**
     * SHA-1摘要算法
     * 计算SHA-1摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-1摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha1Hex(final byte[] data) {
        return Hex.encodeHexString(sha1(data));
    }

    /**
     * SHA-1摘要算法
     * 计算SHA-1摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-1摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sha1Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(sha1(data));
    }

    /**
     * SHA-1摘要算法
     * 计算SHA-1摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-1摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha1Hex(final String data) {
        return Hex.encodeHexString(sha1(data));
    }

//-------------------------------------------- SHA-256 摘要算法 ------------------------------------------------------//

    /**
     * SHA-256摘要算法
     * 计算SHA-256摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-256摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha256(final byte[] data) {
        return getSha256Digest().digest(data);
    }

    /**
     * SHA-256摘要算法
     * 计算SHA-256摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-256摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sha256(final InputStream data) throws IOException {
        return digest(getSha256Digest(), data);
    }

    /**
     * SHA-256摘要算法
     * 计算SHA-256摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-256摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha256(final String data) {
        return sha256(StringUtils.getBytesUtf8(data));
    }

    /**
     * SHA-256摘要算法
     * 计算SHA-256摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-256摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha256Hex(final byte[] data) {
        return Hex.encodeHexString(sha256(data));
    }

    /**
     * SHA-256摘要算法
     * 计算SHA-256摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-256摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sha256Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(sha256(data));
    }

    /**
     * SHA-256摘要算法
     * 计算SHA-256摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-256摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha256Hex(final String data) {
        return Hex.encodeHexString(sha256(data));
    }

//-------------------------------------------- SHA3-224 摘要算法 ------------------------------------------------------//

    /**
     * SHA3-224摘要算法
     * 计算SHA3-224摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-224摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha3_224(final byte[] data) {
        return getSha3_224Digest().digest(data);
    }

    /**
     * SHA3-224摘要算法
     * 计算SHA3-224摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-224摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sha3_224(final InputStream data) throws IOException {
        return digest(getSha3_224Digest(), data);
    }

    /**
     * SHA3-224摘要算法
     * 计算SHA3-224摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-224摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha3_224(final String data) {
        return sha3_224(StringUtils.getBytesUtf8(data));
    }

    /**
     * SHA3-224摘要算法
     * 计算SHA3-224摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-224摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha3_224Hex(final byte[] data) {
        return Hex.encodeHexString(sha3_224(data));
    }

    /**
     * SHA3-224摘要算法
     * 计算SHA3-224摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-224摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sha3_224Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(sha3_224(data));
    }

    /**
     * SHA3-224摘要算法
     * 计算SHA3-224摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-224摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha3_224Hex(final String data) {
        return Hex.encodeHexString(sha3_224(data));
    }

//-------------------------------------------- SHA3-256 摘要算法 ------------------------------------------------------//

    /**
     * SHA3-256摘要算法
     * 计算SHA3-256摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-256摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha3_256(final byte[] data) {
        return getSha3_256Digest().digest(data);
    }

    /**
     * SHA3-256摘要算法
     * 计算SHA3-256摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-256摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sha3_256(final InputStream data) throws IOException {
        return digest(getSha3_256Digest(), data);
    }

    /**
     * SHA3-256摘要算法
     * 计算SHA3-256摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-256摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha3_256(final String data) {
        return sha3_256(StringUtils.getBytesUtf8(data));
    }

    /**
     * SHA3-256摘要算法
     * 计算SHA3-256摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-256摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha3_256Hex(final byte[] data) {
        return Hex.encodeHexString(sha3_256(data));
    }

    /**
     * SHA3-256摘要算法
     * 计算SHA3-256摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-256摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sha3_256Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(sha3_256(data));
    }

    /**
     * SHA3-256摘要算法
     * 计算SHA3-256摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-256摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha3_256Hex(final String data) {
        return Hex.encodeHexString(sha3_256(data));
    }

//-------------------------------------------- SHA3-384 摘要算法 ------------------------------------------------------//

    /**
     * SHA3-384 摘要算法
     * 计算SHA3-384摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-384 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha3_384(final byte[] data) {
        return getSha3_384Digest().digest(data);
    }

    /**
     * SHA3-384 摘要算法
     * 计算SHA3-384摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-384 摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sha3_384(final InputStream data) throws IOException {
        return digest(getSha3_384Digest(), data);
    }

    /**
     * SHA3-384 摘要算法
     * 计算SHA3-384摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-384 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha3_384(final String data) {
        return sha3_384(StringUtils.getBytesUtf8(data));
    }

    /**
     * SHA3-384 摘要算法
     * 计算SHA3-384摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-384 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha3_384Hex(final byte[] data) {
        return Hex.encodeHexString(sha3_384(data));
    }

    /**
     * SHA3-384 摘要算法
     * 计算SHA3-384摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-384 摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sha3_384Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(sha3_384(data));
    }

    /**
     * SHA3-384 摘要算法
     * 计算SHA3-384摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-384 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha3_384Hex(final String data) {
        return Hex.encodeHexString(sha3_384(data));
    }

//-------------------------------------------- SHA3-512 摘要算法 ------------------------------------------------------//

    /**
     * SHA3-512 摘要算法
     * 计算SHA3-512摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-512 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha3_512(final byte[] data) {
        return getSha3_512Digest().digest(data);
    }

    /**
     * SHA3-512 摘要算法
     * 计算SHA3-512摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-512 摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sha3_512(final InputStream data) throws IOException {
        return digest(getSha3_512Digest(), data);
    }

    /**
     * SHA3-512 摘要算法
     * 计算SHA3-512摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-512 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha3_512(final String data) {
        return sha3_512(StringUtils.getBytesUtf8(data));
    }

    /**
     * SHA3-512 摘要算法
     * 计算SHA3-512摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-512 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha3_512Hex(final byte[] data) {
        return Hex.encodeHexString(sha3_512(data));
    }

    /**
     * SHA3-512 摘要算法
     * 计算SHA3-512摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-512 摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sha3_512Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(sha3_512(data));
    }

    /**
     * SHA3-512 摘要算法
     * 计算SHA3-512摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA3-512 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha3_512Hex(final String data) {
        return Hex.encodeHexString(sha3_512(data));
    }

//---------------------------------------- SHA-384 摘要算法 -----------------------------------------------------------//
    /**
     * SHA-384 摘要算法
     * 计算SHA-384摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-384 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha384(final byte[] data) {
        return getSha384Digest().digest(data);
    }

    /**
     * SHA-384 摘要算法
     * 计算SHA-384摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-384 摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sha384(final InputStream data) throws IOException {
        return digest(getSha384Digest(), data);
    }

    /**
     * SHA-384 摘要算法
     * 计算SHA-384摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-384 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha384(final String data) {
        return sha384(StringUtils.getBytesUtf8(data));
    }

    /**
     * SHA-384 摘要算法
     * 计算SHA-384摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-384 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha384Hex(final byte[] data) {
        return Hex.encodeHexString(sha384(data));
    }

    /**
     * SHA-384 摘要算法
     * 计算SHA-384摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-384 摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sha384Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(sha384(data));
    }

    /**
     * SHA-384 摘要算法
     * 计算SHA-384摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-384 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha384Hex(final String data) {
        return Hex.encodeHexString(sha384(data));
    }

//---------------------------------------- SHA-512 摘要算法 -----------------------------------------------------------//
    /**
     * SHA-512 摘要算法
     * 计算SHA-512摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha512(final byte[] data) {
        return getSha512Digest().digest(data);
    }

    /**
     * SHA-512 摘要算法
     * 计算SHA-512摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512 摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sha512(final InputStream data) throws IOException {
        return digest(getSha512Digest(), data);
    }

    /**
     * SHA-512 摘要算法
     * 计算SHA-512摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha512(final String data) {
        return sha512(StringUtils.getBytesUtf8(data));
    }

    /**
     * SHA-512 摘要算法
     * 计算SHA-512摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha512Hex(final byte[] data) {
        return Hex.encodeHexString(sha512(data));
    }

    /**
     * SHA-512 摘要算法
     * 计算SHA-512摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512 摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sha512Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(sha512(data));
    }

    /**
     * SHA-512 摘要算法
     * 计算SHA-512摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha512Hex(final String data) {
        return Hex.encodeHexString(sha512(data));
    }

//---------------------------------------- SHA-512/224 摘要算法 ------------------------------------------------------//
    /**
     * SHA-512/224 摘要算法
     * 计算SHA-512/224摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/224 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha512_224(final byte[] data) {
        return getSha512_224Digest().digest(data);
    }

    /**
     * SHA-512/224 摘要算法
     * 计算SHA-512/224摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/224 摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sha512_224(final InputStream data) throws IOException {
        return digest(getSha512_224Digest(), data);
    }

    /**
     * SHA-512/224 摘要算法
     * 计算SHA-512/224摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/224 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha512_224(final String data) {
        return sha512_224(StringUtils.getBytesUtf8(data));
    }

    /**
     * SHA-512/224 摘要算法
     * 计算SHA-512/224摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/224 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha512_224Hex(final byte[] data) {
        return Hex.encodeHexString(sha512_224(data));
    }

    /**
     * SHA-512/224 摘要算法
     * 计算SHA-512/224摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/224 摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sha512_224Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(sha512_224(data));
    }

    /**
     * SHA-512/224 摘要算法
     * 计算SHA-512/224摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/224 摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sha512_224Hex(final String data) {
        return Hex.encodeHexString(sha512_224(data));
    }

//---------------------------------------- SHA-512/256 摘要算法 ------------------------------------------------------//

    /**
     * SHA-512/256 摘要算法
     * 计算SHA-512/256摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/256 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha512_256(final byte[] data) {
        return getSha512_256Digest().digest(data);
    }

    /**
     * SHA-512/256 摘要算法
     * 计算SHA-512/256摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/256 摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sha512_256(final InputStream data) throws IOException {
        return digest(getSha512_256Digest(), data);
    }

    /**
     * SHA-512/256 摘要算法
     * 计算SHA-512/256摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/256 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sha512_256(final String data) {
        return sha512_256(StringUtils.getBytesUtf8(data));
    }

    /**
     * SHA-512/256 摘要算法
     * 计算SHA-512/256摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/256 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha512_256Hex(final byte[] data) {
        return Hex.encodeHexString(sha512_256(data));
    }

    /**
     * SHA-512/256 摘要算法
     * 计算SHA-512/256摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/256 摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sha512_256Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(sha512_256(data));
    }

    /**
     * SHA-512/256 摘要算法
     * 计算SHA-512/256摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SHA-512/256 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sha512_256Hex(final String data) {
        return Hex.encodeHexString(sha512_256(data));
    }

//-----------------------------------------------  SM3 摘要算法  ------------------------------------------------------//
    /**
     * SM3 摘要算法
     * 计算SM3摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SM3 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sm3(final byte[] data) {
        return getSM3Digest().digest(data);
    }

    /**
     * SM3 摘要算法
     * 计算SM3摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SM3 摘要计算后的字节数组
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static byte[] sm3(final InputStream data) throws IOException {
        return digest(getSha512_256Digest(), data);
    }

    /**
     * SM3 摘要算法
     * 计算SM3摘要并将值返回为{@code byte[]}。
     *
     * @param data      要进行摘要计算的数据
     * @return SM3 摘要计算后的字节数组
     * @since 1.0.7
     */
    public static byte[] sm3(final String data) {
        return sha512_256(StringUtils.getBytesUtf8(data));
    }

    /**
     * SM3 摘要算法
     * 计算SM3摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SM3 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sm3Hex(final byte[] data) {
        return Hex.encodeHexString(sha512_256(data));
    }

    /**
     * SM3 摘要算法
     * 计算SM3摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SM3 摘要计算后的十六进制字符串
     * @throws IOException IO异常
     * @since 1.0.7
     */
    public static String sm36Hex(final InputStream data) throws IOException {
        return Hex.encodeHexString(sha512_256(data));
    }

    /**
     * SM3 摘要算法
     * 计算SM3摘要并将值作为十六进制字符串返回。
     *
     * @param data      要进行摘要计算的数据
     * @return SM3 摘要计算后的十六进制字符串
     * @since 1.0.7
     */
    public static String sm3Hex(final String data) {
        return Hex.encodeHexString(sha512_256(data));
    }
}
